// converter.js
import { convert } from '../../utils/converter.js';

Page({
  data: {
    // 页面数据
    unitType: '',
    unitTypeName: '',
    inputValue: '',
    fromUnit: '',
    toUnit: '',
    resultValue: '',
    units: [],
    fromUnitIndex: 0,
    toUnitIndex: 1,
    darkMode: false,
    conversionFormula: ''
  },

  onLoad: function (options) {
    // 页面加载时执行
    const type = options.type;
    let typeName = '';
    let units = [];
    
    switch (type) {
      case 'length':
        typeName = '长度';
        units = [
          { id: 'mm', name: '毫米' },
          { id: 'cm', name: '厘米' },
          { id: 'm', name: '米' },
          { id: 'km', name: '千米' },
          { id: 'in', name: '英寸' },
          { id: 'ft', name: '英尺' },
          { id: 'yd', name: '码' },
          { id: 'mi', name: '英里' }
        ];
        break;
      case 'area':
        typeName = '面积';
        units = [
          { id: 'mm2', name: '平方毫米' },
          { id: 'cm2', name: '平方厘米' },
          { id: 'm2', name: '平方米' },
          { id: 'ha', name: '公顷' },
          { id: 'km2', name: '平方千米' },
          { id: 'in2', name: '平方英寸' },
          { id: 'ft2', name: '平方英尺' },
          { id: 'yd2', name: '平方码' },
          { id: 'ac', name: '英亩' },
          { id: 'mi2', name: '平方英里' }
        ];
        break;
      case 'weight':
        typeName = '重量';
        units = [
          { id: 'mg', name: '毫克' },
          { id: 'g', name: '克' },
          { id: 'kg', name: '千克' },
          { id: 't', name: '吨' },
          { id: 'oz', name: '盎司' },
          { id: 'lb', name: '磅' }
        ];
        break;
      case 'temperature':
        typeName = '温度';
        units = [
          { id: 'c', name: '摄氏度' },
          { id: 'f', name: '华氏度' },
          { id: 'k', name: '开尔文' }
        ];
        break;
    }
    
    this.setData({
      unitType: type,
      unitTypeName: typeName,
      units: units,
      fromUnit: units[0] ? units[0].id : '',
      toUnit: units[1] ? units[1].id : '',
      fromUnitIndex: 0,
      toUnitIndex: 1
    });
    
    // 检查夜间模式设置
    this.checkDarkMode();
  },

  // 检查夜间模式设置
  checkDarkMode: function () {
    const app = getApp();
    const darkMode = app.globalData.darkMode;
    this.setData({
      darkMode: darkMode
    });
  },

  // 夜间模式变化回调
  onDarkModeChange: function (darkMode) {
    this.setData({
      darkMode: darkMode
    });
  },

  // 输入值改变
  onInputValueChange: function (e) {
    this.setData({
      inputValue: e.detail.value
    });
  },

  // 源单位改变
  onFromUnitChange: function (e) {
    const index = e.detail.value;
    this.setData({
      fromUnit: this.data.units[index].id,
      fromUnitIndex: parseInt(index)
    });
  },

  // 目标单位改变
  onToUnitChange: function (e) {
    const index = e.detail.value;
    this.setData({
      toUnit: this.data.units[index].id,
      toUnitIndex: parseInt(index)
    });
  },

  // 执行换算
  convert: function () {
    const { unitType, unitTypeName, inputValue, fromUnit, toUnit, units } = this.data;
    
    if (inputValue === '') {
      wx.showToast({
        title: '请输入数值',
        icon: 'none'
      });
      return;
    }
    
    // 获取换算结果
    const result = this.calculateResult(unitType, parseFloat(inputValue), fromUnit, toUnit);
    
    // 生成换算公式
    const formula = this.generateConversionFormula(unitType, fromUnit, toUnit, units);
    
    this.setData({
      resultValue: result,
      conversionFormula: formula
    });
    
    // 保存到历史记录
    if (result) {
      this.saveToHistory(unitType, unitTypeName, inputValue, fromUnit, toUnit, result, units);
    }
  },

  // 计算换算结果
  calculateResult: function (type, value, from, to) {
    try {
      const result = convert(type, value, from, to);
      
      // 根据单位换算方向决定是否保留小数
      // 获取单位基准值
      let units = {};
      switch (type) {
        case 'length':
          units = {
            'mm': 0.001,
            'cm': 0.01,
            'm': 1,
            'km': 1000,
            'in': 0.0254,
            'ft': 0.3048,
            'yd': 0.9144,
            'mi': 1609.344
          };
          break;
        case 'area':
          units = {
            'mm2': 0.000001,
            'cm2': 0.0001,
            'm2': 1,
            'ha': 10000,
            'km2': 1000000,
            'in2': 0.00064516,
            'ft2': 0.092903,
            'yd2': 0.836127,
            'ac': 4046.86,
            'mi2': 2589988.11
          };
          break;
        case 'weight':
          units = {
            'mg': 0.001,
            'g': 1,
            'kg': 1000,
            't': 1000000,
            'oz': 28.3495,
            'lb': 453.592
          };
          break;
        case 'temperature':
          // 温度单位特殊处理，保留两位小数
          return result.toFixed(2);
      }
      
      // 如果没有找到单位基准值，保留两位小数
      if (!units[from] || !units[to]) {
        return result.toFixed(2);
      }
      
      // 获取源单位和目标单位的基准值
      const fromBase = units[from];
      const toBase = units[to];
      
      // 统一保留6位小数，然后去除尾部的0
      return parseFloat(result.toFixed(6));
    } catch (error) {
      wx.showToast({
        title: '换算出错',
        icon: 'none'
      });
      return '';
    }
  },

  // 生成换算公式
  generateConversionFormula: function (type, fromUnit, toUnit, units) {
    // 获取单位名称
    const fromUnitObj = units.find(u => u.id === fromUnit);
    const toUnitObj = units.find(u => u.id === toUnit);
    const fromUnitName = fromUnitObj ? fromUnitObj.name : fromUnit;
    const toUnitName = toUnitObj ? toUnitObj.name : toUnit;
    
    // 根据不同类型生成公式
    switch (type) {
      case 'length':
        return `1${fromUnitName} = ${this.getConversionFactor('length', fromUnit, toUnit)}${toUnitName}`;
      case 'area':
        return `1${fromUnitName} = ${this.getConversionFactor('area', fromUnit, toUnit)}${toUnitName}`;
      case 'weight':
        return `1${fromUnitName} = ${this.getConversionFactor('weight', fromUnit, toUnit)}${toUnitName}`;
      case 'temperature':
        // 生成温度换算的具体公式
        if (fromUnit === 'c' && toUnit === 'f') {
          return `(°C × 9/5) + 32 = °F`;
        } else if (fromUnit === 'f' && toUnit === 'c') {
          return `(°F - 32) × 5/9 = °C`;
        } else if (fromUnit === 'c' && toUnit === 'k') {
          return `°C + 273.15 = K`;
        } else if (fromUnit === 'k' && toUnit === 'c') {
          return `K - 273.15 = °C`;
        } else if (fromUnit === 'f' && toUnit === 'k') {
          return `(°F - 32) × 5/9 + 273.15 = K`;
        } else if (fromUnit === 'k' && toUnit === 'f') {
          return `(K - 273.15) × 9/5 + 32 = °F`;
        } else {
          // 如果是相同单位转换
          return `1${fromUnitName} = 1${toUnitName}`;
        }
      default:
        return '';
    }
  },
  
  // 获取换算因子
  getConversionFactor: function (type, fromUnit, toUnit) {
    const { convert } = require('../../utils/converter.js');
    
    // 导入单位换算基准
    let units = {};
    switch (type) {
      case 'length':
        units = {
          'mm': 0.001,
          'cm': 0.01,
          'm': 1,
          'km': 1000,
          'in': 0.0254,
          'ft': 0.3048,
          'yd': 0.9144,
          'mi': 1609.344
        };
        break;
      case 'area':
        units = {
          'mm2': 0.000001,
          'cm2': 0.0001,
          'm2': 1,
          'ha': 10000,
          'km2': 1000000,
          'in2': 0.00064516,
          'ft2': 0.092903,
          'yd2': 0.836127,
          'ac': 4046.86,
          'mi2': 2589988.11
        };
        break;
      case 'weight':
        units = {
          'mg': 0.001,
          'g': 1,
          'kg': 1000,
          't': 1000000,
          'oz': 28.3495,
          'lb': 453.592
        };
        break;
      case 'temperature':
        // 温度换算不使用简单的因子乘法，因此返回固定值1
        return '1';
    }
    
    // 计算换算因子
    const factor = units[fromUnit] / units[toUnit];
    
    // 根据单位换算方向决定是否保留小数
    // 获取源单位和目标单位的基准值
    const fromBase = units[fromUnit];
    const toBase = units[toUnit];
    
    // 统一保留6位小数，然后去除尾部的0
    return parseFloat(factor.toFixed(6));
  },
  
  // 保存到历史记录
  saveToHistory: function (type, typeName, inputValue, fromUnit, toUnit, resultValue, units) {
    // 获取当前时间
    const now = new Date();
    const time = `${now.getFullYear()}-${(now.getMonth() + 1).toString().padStart(2, '0')}-${now.getDate().toString().padStart(2, '0')} ${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}:${now.getSeconds().toString().padStart(2, '0')}`;
    
    // 查找单位名称
    const fromUnitObj = units.find(u => u.id === fromUnit);
    const toUnitObj = units.find(u => u.id === toUnit);
    
    // 构造历史记录项
    const historyItem = {
      type: type,
      typeName: typeName,
      inputValue: inputValue,
      fromUnit: fromUnit,
      toUnit: toUnit,
      fromUnitName: fromUnitObj ? fromUnitObj.name : fromUnit,
      toUnitName: toUnitObj ? toUnitObj.name : toUnit,
      resultValue: resultValue,
      time: time
    };
    
    // 从本地存储获取现有历史记录
    let history = wx.getStorageSync('conversionHistory') || [];
    
    // 添加新记录到开头
    history.unshift(historyItem);
    
    // 限制历史记录数量为50条
    if (history.length > 50) {
      history = history.slice(0, 50);
    }
    
    // 保存到本地存储
    wx.setStorageSync('conversionHistory', history);
  }
});